package com.example.library.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.library.common.Result;
import com.example.library.entity.Book;
import com.example.library.entity.BorrowRecord;
import com.example.library.service.IBookService;
import com.example.library.service.IRecordService;
import com.example.library.utils.TokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;

/**
 * 图书借阅记录管理
 *
 * 该控制器处理与借阅记录相关的操作，如获取所有记录、按用户名查找记录、添加记录、删除记录等。
 * 并通过 TokenUtil 对每个请求进行 Token 验证。
 */
@RestController
@CrossOrigin
@RequestMapping("/record")
@Validated
public class    RecordController {

    @Autowired
    private IRecordService iRecordService;  // 记录服务接口，用于调用记录操作的方法
    @Autowired
    private IBookService iBookService; // 注入书籍服务类
    @Autowired
    private TokenUtil tokenUtil;  // 用于验证请求中的 JWT Token

    /**
     * 获取所有记录
     *
     * 该方法返回数据库中的所有借阅记录，并通过统一的结果结构返回。
     *
     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
     * @return 包含所有记录的 Result 对象
     */
    @GetMapping("/allrecords")
    public Result<List<BorrowRecord>> getAllRecords(@RequestHeader("Authorization") String authorizationHeader) {
        // 验证 Token 是否有效
        Result<String> tokenResult = tokenUtil.validateToken(authorizationHeader);
        if (!tokenResult.isSuccess()) {
            return Result.error(401, "Token 验证失败");
        }

        // 获取所有借阅记录
        List<BorrowRecord> list = iRecordService.list();
        return Result.success(list);  // 返回查询结果
    }

    /**
     * 获取当前用户的借阅记录
     *
     * 该方法从 Token 中获取用户名，并查询该用户的所有借阅记录。
     *
     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
     * @return 包含该用户借阅记录的 Result 对象
     */
    @PostMapping("/allbyname")
    public Result getAllRecordsByName(@RequestHeader("Authorization") String authorizationHeader) {
        // 从请求头中提取 Token，移除 "Bearer " 前缀
        String token = authorizationHeader.startsWith("Bearer ") ? authorizationHeader.substring(7) : authorizationHeader;

        // 验证 Token 是否有效
        Result<String> tokenResult = tokenUtil.validateToken(token);
        if (!tokenResult.isSuccess()) {
            return tokenResult; // 如果 Token 无效，返回相应的错误信息
        }

        // 从 Token 中获取用户名
        String username = tokenUtil.getClaimFromToken(token, "userName");
        System.out.println(username); // 输出用户名调试信息
        if (username == null) {
            return Result.error(401, "无效的 Token，无法获取用户名");
        }

        // 查询指定用户名的借阅记录
        LambdaQueryWrapper<BorrowRecord> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(BorrowRecord::getRecordBorrower, username);
        List<BorrowRecord> borrowRecords = iRecordService.list(lambdaQueryWrapper);
        System.out.println(borrowRecords.size());

        // 返回查询结果（即使列表为空，也返回成功的结果）
        return Result.success(borrowRecords);
    }
//
//    /**
//     * 添加记录
//     *
//     * 该方法用于添加新的借阅记录，借阅时间默认为当前时间，归还时间为两周后。
//     *
//     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
//     * @param borrowRecord 要添加的借阅记录对象
//     * @return 操作结果的 Result 对象
//     */
//    @PostMapping("/addrecord")
//    public Result addRecord(@RequestHeader("Authorization") String authorizationHeader, @RequestBody @Validated BorrowRecord borrowRecord) {
//        // 验证 Token 是否有效
//        Result tokenResult = tokenUtil.validateToken(authorizationHeader);
//        if (!tokenResult.isSuccess()) {
//            return Result.error(401, "Token 验证失败");
//        }
//
//        try {
//
//            String username = tokenUtil.getClaimFromToken(authorizationHeader, "userName");
//            if (username == null) {
//                return Result.error(401, "无效的 Token，无法获取用户名");
//            }
//
//
//            // 设置借阅时间为当前时间
//            LocalDateTime now = LocalDateTime.now();
//            borrowRecord.setRecordBorrowtime(now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
//
//            // 设置归还时间为两周后
//            LocalDateTime returnTime = now.plusWeeks(2);  // 假设借阅期为两周
//            borrowRecord.setRecordRemandtime(returnTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
//
//            // 保存借阅记录
//            boolean isSaved = iRecordService.save(borrowRecord);
//            if (isSaved) {
//                return Result.success("记录添加成功");
//            } else {
//                return Result.error("记录添加失败");
//            }
//        } catch (Exception e) {
//            return Result.error("记录添加过程中出现错误: " + e.getMessage());
//        }
//    }


    /**
     * 根据用户名删除记录
     *
     * 该方法用于根据指定用户名批量删除借阅记录。
     *
     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
     * @param name 要删除记录的用户名
     * @return 操作结果的 Result 对象
     */
    @DeleteMapping("/delete/{name}")
    public Result deleteRecordsByName(@RequestHeader("Authorization") String authorizationHeader,
                                      @PathVariable("name") String name) {
        // 验证 Token 是否有效
        Result<String> tokenResult = tokenUtil.validateToken(authorizationHeader);
        if (!tokenResult.isSuccess()) {
            return Result.error(401, "Token 验证失败");
        }

        // 批量删除该用户的所有借阅记录
        LambdaQueryWrapper<BorrowRecord> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(BorrowRecord::getRecordBorrower, name);
        boolean isDeleted = iRecordService.remove(lambdaQueryWrapper);

        if (isDeleted) {
            return Result.success("记录删除成功");
        } else {
            return Result.error("删除记录失败");
        }
    }

    /**
     * 更新记录
     *
     * 该方法用于根据记录 ID 更新借阅记录信息。
     *
     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
     * @param id 要更新的记录的 ID
     * @param borrowRecord 包含更新信息的记录对象
     * @return 操作结果的 Result 对象
     */
    @PutMapping("/put/{id}")
    public Result updateRecordById(@RequestHeader("Authorization") String authorizationHeader,
                                   @PathVariable("id") Integer id,
                                   @RequestBody @Validated BorrowRecord borrowRecord) {
        // 验证 Token 是否有效
        Result<String> tokenResult = tokenUtil.validateToken(authorizationHeader);
        if (!tokenResult.isSuccess()) {
            return Result.error(401, "Token 验证失败");
        }

        // 确保传入的记录 ID 与路径中的 ID 一致
        borrowRecord.setRecordId(id);

        // 更新记录信息
        boolean isUpdated = iRecordService.updateById(borrowRecord);
        if (isUpdated) {
            return Result.success("记录更新成功");
        }
        return Result.error("记录更新失败");
    }

    /**
     * 获取所有借阅信息
     *
     * 该方法不需要 Token 验证，直接返回所有的借阅信息。
     *
     * @return 包含所有借阅信息的 Result 对象
     */
    @GetMapping("/borrowinginfo")
    public Result<List> getBorrowingInfo() {
        // 获取所有借阅信息
        List<BorrowRecord> borrowingInfoList = iRecordService.list();
        return Result.success(borrowingInfoList);
    }


    /**
     * 获取当前用户尚未归还的图书
     *
     * 从 Token 中获取用户名，并查询该用户借阅且未归还的所有图书。
     *
     * @param authorizationHeader 请求头中的授权信息，包含 JWT Token
     * @return 包含未归还图书信息的 Result 对象
     */
    @GetMapping("/unreturnedbooks")
    public Result<List<Book>> getUnreturnedBooks(@RequestHeader("Authorization") String authorizationHeader) {
        // 验证 Token 是否有效
        Result<String> tokenResult = tokenUtil.validateToken(authorizationHeader);
        System.out.println(tokenResult+"00000000");
        if (!tokenResult.isSuccess()) {
            return Result.error(401, "Token 验证失败");
        }

        // 从 Token 中获取用户名
        String username = tokenUtil.getClaimFromToken(authorizationHeader, "userName");
        if (username == null) {
            return Result.error(401, "无效的 Token，无法获取用户名");
        }

        // 查询指定用户名且未归还的图书
        LambdaQueryWrapper<Book> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Book::getBookBorrower, username)
                .eq(Book::getBookStatus, '1'); // Assuming '1' indicates borrowed

        List<Book> unreturnedBooks = iBookService.list(lambdaQueryWrapper);

        // 返回查询结果
        return Result.success(unreturnedBooks);
    }

}
